﻿#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
using namespace std;

//class Base1
//{
//	//
//};
//struct Base2
//{
//	//
//};
//
////class Base3 : Base1, Base2
////{
////	//
////};
//
//class Base3 : private Base1, public Base2
//{
//	//
//};

//class Person
//{
//protected:
//	int _num = 111;
//};
//
//class Student : public Person
//{
//public:
//	void Print()
//	{
//		//隐藏了基类对成员的直接访问
//		cout << "学号：" << _num << endl;
//		//显示调用
//		cout << "学号：" << Person::_num << endl;
//	}
//protected:
//	int _num = 99;
//};
//
//int main()
//{
//	Student s1;
//	s1.Print();
//	return 0;
//}

//class A
//{
//public:
//	void fun()
//	{
//		cout << "func()" << endl;
//	}
//};
//class B : public A
//{
//public:
//	void fun(int i)
//	{
//		cout << "func(int i)" << i << endl;
//	}
//};
//int main()
//{
//	B b;
//	//b.fun(10);
//	b.fun();
//	return 0;
//};

//class Person
//{
//protected:
//	string _name; // 姓名
//	string _sex;  // 性别
//	int _age;  // 年龄
//};
//class Student : public Person
//{
//public:
//	int _No; // 学号
//};
//int main()
//{
//	Student sobj;
//	// 1.派⽣类对象可以赋值给基类的指针
//
//	Person * pp = &sobj;
//	Person& rp = sobj;
//	Person pobj = sobj;
//	// 派⽣类对象可以赋值给基类的对象是通过调⽤后⾯会讲解的基类的拷⻉构造完成的
//
//	//2.基类对象不能赋值给派⽣类对象，这⾥会编译报错
//	//sobj = pobj;
//	return 0;
//}

//class Person
//{
//public:
//	Person(const char* name = "peter")
//		: _name(name)
//	{
//		cout << "Person()构造函数" << endl;
//	}
//    Person(const Person& p)
//        : _name(p._name)
//    {
//        cout << "Person(const Person& p)拷贝构造函数" << endl;
//    }
//
//    Person& operator=(const Person& p)
//    {
//        cout << "Person operator=(const Person& p)" << endl;
//        if (this != &p)
//            _name = p._name;
//
//        return *this;
//    }
//
//    ~Person()
//    {
//        cout << "~Person()析构函数" << endl;
//    }
//protected:
//    string _name; //姓名
//};
//class Student : public Person
//{
//public:
//    Student(const char* name, int num)
//        : Person(name)
//        , _num(num)
//    {
//        cout << "Student()构造函数" << endl;
//    }
//
//    Student(const Student& s)
//        : Person(s)
//        , _num(s._num)
//    {
//        cout << "Student(const Student& s)拷贝构造函数" << endl;
//    }
//
//    Student& operator = (const Student& s)
//    {
//        cout << "Student& operator= (const Student& s)" << endl;
//        if (this != &s)
//        {
//            //构成隐藏，所以需要显⽰调⽤
//            Person::operator =(s);
//            _num = s._num;
//        }
//        return *this;
//    }
//
//    ~Student()
//    {
//        cout << "~Student()析构函数" << endl;
//    }
//protected:
//    int _num; //    学号
//
//};
//int main()
//{
//    Student s1("jack", 18);
//    Student s2(s1);
//    Student s3("rose", 17);
//    s1 = s3;
//
//    return 0;
//}

//class Person
//{
//public:
//	string _name;
//	static int _count;
//};
//
////静态成员要在类外初始化
//int Person::_count = 0;
//
//class Student : public Person
//{
//protected:
//	int _stuNum;
//};
//int main()
//{
//	Person p;
//	Student s;
//
//	// 这⾥的运⾏结果可以看到⾮静态成员	_name的地址是不⼀样的
//	// 说明派⽣类继承下来了，⽗派⽣类对象各有⼀份
//	cout << &p._name << endl;
//	cout << &s._name << endl;
//
//	// 这⾥的运⾏结果可以看到静态成员 _count的地址是⼀样的
//	// 说明派⽣类和基类共⽤同⼀份静态成员
//	cout << &p._count << endl;
//	cout << &s._count << endl;
//
//	// 公有的情况下，⽗派⽣类指定类域都可以访问静态成员
//	cout << Person::_count << endl;
//	cout << Student::_count << endl;
//	return 0;
//}

//class Person
//{
//public:
//	int age;
//};
//class Student1 : public Person
//{ };
//class Student2 : public Person
//{ };
//class Bat : public Student1, public Student2
//{ };
//
//int main()
//{
//	return 0;
//}

//class Animal{};
//
//class Mammal : public virtual Animal{}; // 虚拟继承
//class Bird : public virtual Animal{}; //虚拟继承
//
//class Bat : public Mammal, public Bird{};

